@swc-node/core

What is @swc-node/core?

@swc-node/core is a Node.js binding for the SWC (Speedy Web Compiler) project, which is a super-fast TypeScript/JavaScript compiler written in Rust. It allows you to transform and compile TypeScript and JavaScript code with high performance.

What are @swc-node/core's main functionalities?

Transforming Code

This feature allows you to transform TypeScript or JavaScript code into JavaScript. The `transformSync` function takes the source code and an options object, and returns the transformed code.

const { transformSync } = require('@swc-node/core');

const output = transformSync('const x: number = 1;', { jsc: { parser: { syntax: 'typescript' } } });
console.log(output.code);

Compiling Code

This feature allows you to compile TypeScript or JavaScript code asynchronously. The `compile` function takes the source code and an options object, and returns a promise that resolves to the compiled code.

const { compile } = require('@swc-node/core');

compile('const x: number = 1;', { jsc: { parser: { syntax: 'typescript' } } }).then(output => {
  console.log(output.code);
});

Using with Node.js

This feature allows you to use SWC with Node.js directly. By requiring `@swc-node/register`, you can run TypeScript code in Node.js without pre-compiling it.

require('@swc-node/register');

const x: number = 1;
console.log(x);

Other packages similar to @swc-node/core

typescript

TypeScript is a language for application-scale JavaScript. It includes a compiler that can compile TypeScript code to JavaScript. Compared to @swc-node/core, TypeScript's compiler is slower but offers more comprehensive type-checking and language features.

babel

Babel is a JavaScript compiler that allows you to use next-generation JavaScript, today. It can transform syntax, polyfill features that are missing in your target environment, and more. Babel is more feature-rich but slower compared to @swc-node/core.

esbuild

esbuild is an extremely fast JavaScript bundler and minifier. It supports TypeScript and modern JavaScript syntax out of the box. esbuild is comparable to @swc-node/core in terms of speed but focuses more on bundling and minification.

README

@swc-node/core

🚀 Help me to become a full-time open-source developer by sponsoring me on Github

Benchmark

transform AjaxObservable.ts to ES2015 & CommonJS JavaScript.

@swc-node/core x 151 ops/sec ±3.74% (77 runs sampled)
@swc/core x 107 ops/sec ±0.51% (78 runs sampled)
esbuild x 52.89 ops/sec ±1.58% (67 runs sampled)
typescript x 21.08 ops/sec ±9.68% (40 runs sampled)
Transform rxjs/AjaxObservable.ts benchmark bench suite: Fastest is @swc-node/core

Usage

export interface Options {
  target?: 'es3' | 'es5' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020'
  module?: 'commonjs' | 'umd' | 'amd' | 'es6'
  sourcemap?: boolean | 'inline'
  experimentalDecorators?: boolean
  emitDecoratorMetadata?: boolean
  dynamicImport?: boolean
  esModuleInterop?: boolean
  keepClassNames?: boolean
  react?: Partial<ReactConfig>
  paths?: {
    [from: string]: [string]
  }
}

export interface ReactConfig {
  /**
   * Replace the function used when compiling JSX expressions.
   *
   * Defaults to `React.createElement`.
   */
  pragma: string
  /**
   * Replace the component used when compiling JSX fragments.
   *
   * Defaults to `React.Fragment`
   */
  pragmaFrag: string
  /**
   * Toggles whether or not to throw an error if a XML namespaced tag name is used. For example:
   * `<f:image />`
   *
   * Though the JSX spec allows this, it is disabled by default since React's
   * JSX does not currently have support for it.
   *
   */
  throwIfNamespace: boolean
  /**
   * Toggles plugins that aid in development, such as @swc/plugin-transform-react-jsx-self
   * and @swc/plugin-transform-react-jsx-source.
   *
   * Defaults to `false`,
   *
   */
  development: boolean
  /**
   * Use `Object.assign()` instead of `_extends`. Defaults to false.
   */
  useBuiltins: boolean
}

export function transformSync(
  source: string | Buffer,
  path: string,
  options?: Options,
): {
  code: string
  map: string
}

export function transform(
  source: string | Buffer,
  path: string,
  options?: Options,
): Promise<{
  code: string
  map: string
}>